A typical web browser receives data from a web server defining the appearance and rudimentary behavior of a web page for display on a client system. In a typical scenario, a user specifies a Uniform Resource Locator (“URL”), a global address of a resource on the World Wide Web, an intranet, and other computer networks to access a desired web site. An example URL is “http://www.microsoft.com/ms.htm”. The first part of the example URL indicates a given protocol (i.e., “http”) to be used in the communication. The second part specifies the domain name (i.e., “www.microsoft.com”) where the resource is located. The third part specifies the resource (i.e., a file called “ms.htm”) within the domain. Accordingly, a browser generates an HTTP (Hypertext Transport Protocol) request associated with the example URL to retrieve the data associated with ms.htm file within the www.microsoft.com domain. A web server hosting the www.microsoft.com site receives the HTTP request and returns the requested web page or resource in an HTTP response to the client system for display in the browser.
The “ms.htm” file of the example above corresponds to a web page file that includes static HTML (Hypertext Markup Language) code. HTML is a plain-text authoring language used to create documents (e.g., web pages) on the World Wide Web. As such, an HTML file can be retrieved from a web server by a client browser which converts the HTML code to actual visual images or audio components and is thus displayed as a web page. On the client computer systems, this process displays the web page content defined by the delivered HTML file. Using HTML, a developer can, for example, specify formatted text, lists, forms, tables, hypertext links, inline images and sounds, and background graphics for display in the browser. An HTML file, however, is a static file that does not inherently support dynamic generation of web page content. Web page content is the HTML code that is returned to the client for display. Dynamic operation of such relates to a server side application that, as a result of processing steps, generates the HTML code prior to sending as opposed to just sending predetermined code to client browser.
In order to handle more complex client-server interaction, server-side application programs have developed to handle more complex client-server interaction, such as the providing of dynamic content, e.g., changing stock prices or traffic information. The server-side application program processes the HTTP request and dynamically generates the appropriate HTML code for transmission to the client in an HTTP response. For example, a server-side application program can process query strings and data from Web-based forms provided by the client in HTTP requests to dynamically generate HTML code for transmission in an HTTP response to the client. In essence, the server side application can generate an HTML-type file that is customized based on information in a request from a client. In such a case, there is no static HTML file that is stored on the server; the HTML file is dynamically created at runtime. An exemplary server-side application program may generate HTML code using a sequence of one or more formatted text write operations to a memory structure. Thereafter, the resulting text is transmitted to a client system in an HTTP response, where it is displayed in the browser.
Developing a server-side application program can be a complex task requiring not only familiarity with normal HTML coding that is used to layout a Web page, but also with programming basics, including one or more programming languages (e.g., C++, Perl, Visual Basic, or Jscript). Unfortunately however, many Web page designers are frequently graphics designers and editors, who provide the human touch but often lack programming experience. Thus, there is a need to provide a simplified web page development framework to create web page files that allows those with less programming experience to develop web page interfaces between server side applications and their respective clients. It is desirable, therefore, to provide a development framework to allow a developer to dynamically create and process a web page with minimal programming.
One approach to minimize the programming requirements of dynamic web page generation has been the Active Server Page (ASP) framework, provided by Microsoft Corporation. The ASP framework allows developers to create “ASP” web page files that typically include Visual Basic or Jscript code, as well as other HTML code. The ASP file contains declarations or tags that perform various functions as well as VB script or Jscript code. These declarations are generally easier to write than writing actual programming code.
During operation, the HTTP request specifies the ASP file as the desired resource and, thereafter, the ASP file is used to generate the resulting HTML code in the HTTP response to the client. Furthermore, an ASP file may reference pre-developed or third party server-side library components (e.g., server-side ACTIVEX controls) as well as data bases or other third party applications to ease a given application programming efforts.
The ASP web page file must be converted at runtime to a script that can be interpreted by a script engine. The script engine typically performs the various declaration-type commands in the ASP file in a consecutive or synchronous manner to achieve the desired result. Compared to files that are compiled and stored as executable files, script files run by script engines are generally slower since the script engine must perform an interpretation function rather than simply running the file.
One particular problem with compiling a script file into an executable file is that there is or maybe a combination of various languages in the script file. For example, the script file may include components written in HTML and others written in Visual Basic. The script engine uses various operations to interpret these elements at runtime, but no compilers exist to translate the different language components to a single language, i.e., a single source code file. Moreover, in the current server-side application frameworks, the programming required to dynamically manage client-side user interface elements (e.g., text boxes, list boxes, buttons, hypertext links, images, sounds, etc.) within server-side applications can still require sophisticated programming skills. As these server-side processes become more complex, script engines will not be able to continuously keep up with the demands.
At the same time, programming models that allow reusable elements to be created and specified using easy-to-understand script-based programming language permit a larger universe of potential programmers to create programming objects. As a result, script-language based programming model text addresses the complexity and performance needs of service side programs are highly desirable. For these and other reasons the present invention has been made.